home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-9.10-netbook-remix-PL.iso / casper / filesystem.squashfs / usr / share / pyshared / snack.py < prev    next >
Text File  |  2008-07-30  |  30KB  |  978 lines
  1. # snack.py: maps C extension module _snack to proper python types in module
  2. # snack.
  3. # The first section is a very literal mapping.
  4. # The second section contains convenience classes that amalgamate
  5. # the literal classes and make them more object-oriented.
  6.  
  7. """
  8. This module provides the NEWT Windowing toolkit API for Python
  9. This is a lightweight text-mode windowing library, based on slang.
  10.  
  11. Classes:
  12.  
  13.  - Widget  
  14.  - Button  
  15.  - CompactButton
  16.  - Checkbox
  17.  - SingleRadioButton
  18.  - Listbox
  19.  - Textbox
  20.  - TextboxReflowed
  21.  - Label
  22.  - Scale
  23.  - Entry
  24.  - Form
  25.  - Grid
  26.  - SnackScreen
  27.  - RadioGroup
  28.  - RadioBar
  29.  - ButtonBar
  30.  - GridFormHelp
  31.  - GridForm
  32.  - CheckboxTree
  33.  - Clistbox
  34.  
  35. Functions:
  36.  
  37.  - ListboxChoiceWindow
  38.  - ButtonChoiceWindow
  39.  - EntryWindow
  40. """
  41.  
  42. import _snack
  43. import types
  44. import string
  45.  
  46. from _snack import FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE, FD_READ, FD_WRITE, FD_EXCEPT
  47.  
  48. LEFT = (-1, 0)
  49. DOWN = (-1, -1)
  50. CENTER = (0, 0)
  51. UP = (1, 1)
  52. RIGHT = (1, 0)
  53.  
  54. snackArgs = {"append":-1}
  55.  
  56. class Widget:
  57.     """Base class for NEWT toolkit - Do not use directly
  58.  
  59.     methods:
  60.  
  61.      - Widget(self)
  62.      - setCallback(self, obj, data = None) : 
  63.           The callback for when object activated.
  64.           data is passed to obj.
  65.     """
  66.     def setCallback(self, obj, data = None):
  67.         if data:
  68.             self.w.setCallback(obj, data)
  69.         else:
  70.             self.w.setCallback(obj)
  71.             
  72.     def __init__(self):
  73.         raise NotImplementedError
  74.  
  75. class Button(Widget):
  76.     """Basic button class, takes button text as parameter
  77.  
  78.     method:
  79.  
  80.      - Button(self, text): returns a button
  81.     """
  82.     def __init__(self, text):
  83.         self.w = _snack.button(text)
  84.  
  85. class CompactButton(Widget):
  86.     """Compact Button class (less frilly button decoration).
  87.  
  88.     methods:
  89.  
  90.      - CompactButton(self,text) : create button, with text.
  91.     """
  92.     def __init__(self, text):
  93.         self.w = _snack.compactbutton(text)
  94.  
  95. class Checkbox(Widget):
  96.     """A checkbox.
  97.  
  98.     methods:
  99.     
  100.       - Checkbox(self, text, isOn = 0) : text, and boolean as to default value
  101.       - setValue(self)                 : set value
  102.       - value(self, value)             : return checkbox value
  103.       - selected(self)                 : returns boolean
  104.       - setFlags(self, flag, sense)    : set flags
  105.  
  106.       flags:  FLAG_DISABLED, FLAGS_SET, FLAGS_RESET
  107.     """
  108.     def value(self):
  109.         return self.w.checkboxValue
  110.  
  111.     def selected(self):
  112.         return self.w.checkboxValue != 0
  113.  
  114.     def setFlags (self, flag, sense):
  115.  
  116.         return self.w.checkboxSetFlags(flag, sense)
  117.  
  118.     def setValue (self, value):
  119.         return self.w.checkboxSetValue(value)
  120.  
  121.     def __init__(self, text, isOn = 0):
  122.         self.w = _snack.checkbox(text, isOn)
  123.  
  124. class SingleRadioButton(Widget):
  125.     """Single Radio Button.
  126.  
  127.     methods:
  128.     
  129.      -  SingleRadioButton(text, group, isOn = 0)  : create button
  130.      -  selected(self)                            : returns bool, whether or not is selected.
  131.     """
  132.     
  133.     def selected(self):
  134.         return self.w.key == self.w.radioValue;
  135.     
  136.     def __init__(self, text, group, isOn = 0):
  137.         if group:
  138.             self.w = _snack.radiobutton(text, group.w, isOn)
  139.         else:
  140.             self.w = _snack.radiobutton(text, None, isOn)
  141.  
  142. class Listbox(Widget):
  143.     """Listbox class.
  144.  
  145.     methods:
  146.  
  147.      - Listbox(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0)
  148.      - insert(self, text, item, before) : insert element; before = key to item to insert before, or None.
  149.      - delete(self, item)               : delete item from list.
  150.      - replace(self, text,item)         : Replace a given item's text
  151.      - current(self)                    : returns currently selected item
  152.      - getSelection(self)               : returns a list of selected items
  153.      - setCurrent(self,i tem)           : select current.
  154.      - clear(self)                      : clear listbox
  155.     """
  156.     
  157.     def append(self, text, item):
  158.         key = self.w.listboxAddItem(text)
  159.         self.key2item[key] = item
  160.         self.item2key[item] = key
  161.  
  162.     def insert(self, text, item, before):
  163.         if (not before):
  164.             key = self.w.listboxInsertItem(text, 0)
  165.         else:
  166.             key = self.w.listboxInsertItem(text, self.item2key[before])
  167.         self.key2item[key] = item
  168.         self.item2key[item] = key
  169.  
  170.     def delete(self, item):
  171.         self.w.listboxDeleteItem(self.item2key[item])
  172.         del self.key2item[self.item2key[item]]
  173.         del self.item2key[item]
  174.  
  175.     def replace(self, text, item):
  176.         key = self.w.listboxInsertItem(text, self.item2key[item])
  177.         self.w.listboxDeleteItem(self.item2key[item])
  178.         del self.key2item[self.item2key[item]]
  179.         self.item2key[item] = key
  180.         self.key2item[key] = item
  181.  
  182.     def current(self):
  183.         return self.key2item[self.w.listboxGetCurrent()]
  184.  
  185.     def getSelection(self):
  186.         selection = []
  187.         list = self.w.listboxGetSelection()
  188.         for key in list:
  189.             selection.append(self.key2item[key])
  190.         return selection
  191.  
  192.     def setCurrent(self, item):
  193.         self.w.listboxSetCurrent(self.item2key[item])
  194.  
  195.     def clear(self):
  196.         self.key2item = {}
  197.         self.item2key = {}        
  198.         self.w.listboxClear()
  199.  
  200.     def __init__(self, height, scroll = 0, returnExit = 0, width = 0, showCursor = 0, multiple = 0, border = 0):
  201.         self.w = _snack.listbox(height, scroll, returnExit, showCursor, multiple, border)
  202.         self.key2item = {}
  203.         self.item2key = {}
  204.         if (width):
  205.             self.w.listboxSetWidth(width)
  206.  
  207. class Textbox(Widget):
  208.     """Textbox, container for text.
  209.  
  210.     methods:
  211.  
  212.      - Textbox(self, width, height, scroll = 0, wrap = 0): scroll, wrap are flags
  213.                                    include scroll bars, or text wrap.
  214.      - setText(text) : set text.
  215.      - setHeight(height): set height.
  216.     """
  217.     
  218.     def setText(self, text):
  219.         self.w.textboxText(text)
  220.  
  221.     def setHeight(self, height):
  222.         self.w.textboxHeight(height)
  223.  
  224.     def __init__(self, width, height, text, scroll = 0, wrap = 0):
  225.         self.w = _snack.textbox(width, height, text, scroll, wrap)
  226.  
  227. class TextboxReflowed(Textbox):
  228.  
  229.     def __init__(self, width, text, flexDown = 5, flexUp = 10, maxHeight = -1):
  230.         (newtext, width, height) = reflow(text, width, flexDown, flexUp)
  231.         if maxHeight != -1 and height > maxHeight:
  232.             Textbox.__init__(self, width, maxHeight, newtext, 1)
  233.         else:
  234.             Textbox.__init__(self, width, height, newtext, 0)
  235.  
  236. class Label(Widget):
  237.     """A Label (simple text).
  238.  
  239.     methods:
  240.  
  241.      - Label(self,text)   : create label
  242.      - setText(self,text) : change text.
  243.     """
  244.     def setText(self, text):
  245.         self.w.labelText(text)
  246.  
  247.     def __init__(self, text):
  248.         self.w = _snack.label(text)
  249.  
  250. class Scale(Widget):
  251.     """A Scale (progress bar).
  252.  
  253.     methods:
  254.  
  255.      - Scale(self,width, total) : create scale; width: size on screen, fullamount: integer.
  256.      - set(self,amount)         : set amount to integer.
  257.     """
  258.     def set(self, amount):
  259.         self.w.scaleSet(amount)
  260.  
  261.     def __init__(self, width, total):
  262.         self.w = _snack.scale(width, total)
  263.  
  264. class Entry(Widget):
  265.     """Entry widget.
  266.  
  267.     methods:
  268.  
  269.      - Entry(self, width, text = "", hidden = 0, password = 0, scroll = 1, returnExit = 0)
  270.           constructor. hidden doesn't show text, password stars it out,
  271.           scroll includes scroll bars;
  272.           if returnExit is set, return from Form when exiting this element, else
  273.            proceed to next entry widget.
  274.      - value(self): return value.
  275.      - set(text, cursorAtEnd = 1) : set the text
  276.      - setFlags (flag, sense) : flags can be FLAG_DISABLED, FLAGS_SET, FLAGS_RESET, FLAGS_TOGGLE
  277.     """
  278.     def value(self):
  279.         return self.w.entryValue
  280.  
  281.     def set(self, text, cursorAtEnd = 1):
  282.         return self.w.entrySetValue(text, cursorAtEnd)
  283.  
  284.     def setFlags (self, flag, sense):
  285.         return self.w.entrySetFlags(flag, sense)
  286.  
  287.     def __init__(self, width, text = "", hidden = 0, password = 0, scroll = 1, 
  288.          returnExit = 0):
  289.         self.w = _snack.entry(width, text, hidden, password, scroll, returnExit)
  290.  
  291.  
  292. # Form uses hotkeys
  293. hotkeys = { "F1" : _snack.KEY_F1, "F2" : _snack.KEY_F2, "F3" : _snack.KEY_F3, 
  294.             "F4" : _snack.KEY_F4, "F5" : _snack.KEY_F5, "F6" : _snack.KEY_F6, 
  295.             "F7" : _snack.KEY_F7, "F8" : _snack.KEY_F8, "F9" : _snack.KEY_F9, 
  296.             "F10" : _snack.KEY_F10, "F11" : _snack.KEY_F11, 
  297.             "F12" : _snack.KEY_F12, "ESC" : _snack.KEY_ESC ,  " " : ord(" ") }
  298.  
  299. for n in hotkeys.keys():
  300.     hotkeys[hotkeys[n]] = n
  301.  
  302. class Form:
  303.     """ Base Form class, from which Grid, etc. inherit
  304.  
  305.     methods:
  306.  
  307.      - Form(self, helpArg = None) : constructor. 
  308.      - addHotKey(self, keyname) : keynames of form "F1" through "F12", "ESC"
  309.      - add(self, widget) : Add a widget
  310.      - run(self): run a  form, expecting input
  311.      - draw(self): draw form.
  312.      - setTimer(self, timer) : add a timer
  313.      - watchFile(self, file, flags) : watch a named file
  314.      - setCurrent (self, co): Set a given widget as the current focus
  315.     """
  316.     def addHotKey(self, keyname):
  317.         self.w.addhotkey(hotkeys[keyname])
  318.  
  319.     def add(self, widget):
  320.         if widget.__dict__.has_key('hotkeys'):
  321.             for key in widget.hotkeys.keys():
  322.                 self.addHotKey(key)
  323.  
  324.         if widget.__dict__.has_key('gridmembers'):
  325.             for w in widget.gridmembers:
  326.                 self.add(w)
  327.         elif widget.__dict__.has_key('w'):
  328.             self.trans[widget.w.key] = widget
  329.             return self.w.add(widget.w)
  330.         return None
  331.  
  332.     def run(self):
  333.         (what, which) = self.w.run()
  334.         if (what == _snack.FORM_EXIT_WIDGET):
  335.             return self.trans[which]
  336.         elif (what == _snack.FORM_EXIT_TIMER):
  337.             return "TIMER"
  338.         elif (what == _snack.FORM_EXIT_FDREADY):
  339.             return self.filemap[which]
  340.  
  341.         return hotkeys[which]
  342.  
  343.     def draw(self):
  344.         self.w.draw()
  345.         return None
  346.  
  347.     def __init__(self, helpArg = None):
  348.         self.trans = {}
  349.         self.filemap = {}
  350.         self.w = _snack.form(helpArg)
  351.         # we do the reference count for the helpArg in python! gross
  352.         self.helpArg = helpArg
  353.  
  354.     def setCurrent (self, co):
  355.         self.w.setcurrent (co.w)
  356.  
  357.     def setTimer (self, timer):
  358.         self.w.settimer (timer)
  359.  
  360.     def watchFile (self, file, flags):
  361.         self.filemap[file.fileno()] = file
  362.         self.w.watchfd (file.fileno(), flags)
  363.  
  364. class Grid:
  365.     """Grid class.
  366.  
  367.     methods:
  368.  
  369.      - place(self,x,y): Return what is placed at (x,y)
  370.      - setField(self, what, col, row, padding = (0, 0, 0, 0),
  371.                 anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  372.                 anchorBottom = 0, growx = 0, growy = 0):
  373.                 used to add widget 'what' to grid.
  374.      - Grid(self, *args): eg. g = Grid(2,3) for 2x3 grid
  375.     """
  376.     def place(self, x, y):
  377.         return self.g.place(x, y)
  378.  
  379.     def setField(self, what, col, row, padding = (0, 0, 0, 0),
  380.          anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  381.          anchorBottom = 0, growx = 0, growy = 0):
  382.         self.gridmembers.append(what)
  383.         anchorFlags = 0
  384.         if (anchorLeft):
  385.             anchorFlags = _snack.ANCHOR_LEFT
  386.         elif (anchorRight):
  387.             anchorFlags = _snack.ANCHOR_RIGHT
  388.  
  389.         if (anchorTop):
  390.             anchorFlags = anchorFlags | _snack.ANCHOR_TOP
  391.         elif (anchorBottom):
  392.             anchorFlags = anchorFlags | _snack.ANCHOR_BOTTOM
  393.  
  394.         gridFlags = 0
  395.         if (growx):
  396.             gridFlags = _snack.GRID_GROWX
  397.         if (growy):
  398.             gridFlags = gridFlags | _snack.GRID_GROWY
  399.  
  400.         if (what.__dict__.has_key('g')):
  401.             return self.g.setfield(col, row, what.g, padding, anchorFlags,
  402.                        gridFlags)
  403.         else:
  404.             return self.g.setfield(col, row, what.w, padding, anchorFlags)
  405.     
  406.     def __init__(self, *args):
  407.         self.g = apply(_snack.grid, args)
  408.         self.gridmembers = []
  409.  
  410. colorsets = { "ROOT" : _snack.COLORSET_ROOT,
  411.               "BORDER" : _snack.COLORSET_BORDER,
  412.               "WINDOW" : _snack.COLORSET_WINDOW,
  413.               "SHADOW" : _snack.COLORSET_SHADOW,
  414.               "TITLE" : _snack.COLORSET_TITLE,
  415.               "BUTTON" : _snack.COLORSET_BUTTON,
  416.               "ACTBUTTON" : _snack.COLORSET_ACTBUTTON,
  417.               "CHECKBOX" : _snack.COLORSET_CHECKBOX,
  418.               "ACTCHECKBOX" : _snack.COLORSET_ACTCHECKBOX,
  419.               "ENTRY" : _snack.COLORSET_ENTRY,
  420.               "LABEL" : _snack.COLORSET_LABEL,
  421.               "LISTBOX" : _snack.COLORSET_LISTBOX,
  422.               "ACTLISTBOX" : _snack.COLORSET_ACTLISTBOX,
  423.               "TEXTBOX" : _snack.COLORSET_TEXTBOX,
  424.               "ACTTEXTBOX" : _snack.COLORSET_ACTTEXTBOX,
  425.               "HELPLINE" : _snack.COLORSET_HELPLINE,
  426.               "ROOTTEXT" : _snack.COLORSET_ROOTTEXT,
  427.               "EMPTYSCALE" : _snack.COLORSET_EMPTYSCALE,
  428.               "FULLSCALE" : _snack.COLORSET_FULLSCALE,
  429.               "DISENTRY" : _snack.COLORSET_DISENTRY,
  430.               "COMPACTBUTTON" : _snack.COLORSET_COMPACTBUTTON,
  431.               "ACTSELLISTBOX" : _snack.COLORSET_ACTSELLISTBOX,
  432.               "SELLISTBOX" : _snack.COLORSET_SELLISTBOX }
  433.  
  434. class SnackScreen:
  435.     """A Screen;
  436.  
  437.     methods:
  438.  
  439.     - Screen(self) : constructor
  440.     - finish(self)
  441.     - resume(self)
  442.     - suspend(self)
  443.     - doHelpCallback(self,arg) call callback with arg
  444.     - helpCallback(self,cb): Set help callback
  445.     - suspendcallback(self,cb, data=None) : set callback. data=data to pass to cb.
  446.     - openWindow(self,left, top, width, height, title): Open a window.
  447.     - pushHelpLine(self,text): put help line on screen. Returns current help line if text=None
  448.     - setColor(self, colorset, fg, bg): Set foreground and background colors;
  449.             colorset = key from snack.colorsets,
  450.             fg & bg = english color names defined by S-Lang
  451.                 (ref: S-Lang Library C Programmer's Guide section:
  452.                 8.4.4.  Setting Character Attributes)
  453.     """
  454.     def __init__(self):
  455.         _snack.init()
  456.         (self.width, self.height) = _snack.size()
  457.         self.pushHelpLine(None)
  458.  
  459.     def finish(self):
  460.         return _snack.finish()
  461.  
  462.     def resume(self):
  463.         _snack.resume()
  464.  
  465.     def suspend(self):
  466.         _snack.suspend()
  467.  
  468.     def doHelpCallback(self, arg):
  469.         self.helpCb(self, arg)
  470.     
  471.     def helpCallback(self, cb):
  472.         self.helpCb = cb
  473.         return _snack.helpcallback(self.doHelpCallback)
  474.  
  475.     def suspendCallback(self, cb, data = None):
  476.         if data:
  477.             return _snack.suspendcallback(cb, data)
  478.         return _snack.suspendcallback(cb)
  479.  
  480.     def openWindow(self, left, top, width, height, title):
  481.         return _snack.openwindow(left, top, width, height, title)
  482.  
  483.     def pushHelpLine(self, text):
  484.         if (not text):
  485.             return _snack.pushhelpline("*default*")
  486.         else:
  487.             return _snack.pushhelpline(text)
  488.  
  489.     def popHelpLine(self):
  490.         return _snack.pophelpline()
  491.  
  492.     def drawRootText(self, left, top, text):
  493.         return _snack.drawroottext(left, top, text)
  494.  
  495.     def centeredWindow(self, width, height, title):
  496.         return _snack.centeredwindow(width, height, title)
  497.  
  498.     def gridWrappedWindow(self, grid, title, x = None, y = None):
  499.         if x and y:
  500.             return _snack.gridwrappedwindow(grid.g, title, x, y)
  501.  
  502.         return _snack.gridwrappedwindow(grid.g, title)
  503.  
  504.     def popWindow(self, refresh = True):
  505.         if refresh:
  506.             return _snack.popwindow()
  507.         return _snack.popwindownorefresh()
  508.  
  509.     def refresh(self):
  510.         return _snack.refresh()
  511.  
  512.     def setColor(self, colorset, fg, bg):
  513.         return _snack.setcolor(colorsets[colorset], fg, bg)
  514.  
  515. def reflow(text, width, flexDown = 5, flexUp = 5):
  516.     """ returns a tuple of the wrapped text, the actual width, and the actual height
  517.     """
  518.     return _snack.reflow(text, width, flexDown, flexUp)
  519.  
  520. # combo widgets
  521.  
  522. class RadioGroup(Widget):
  523.     """ Combo widget: Group of Radio buttons
  524.  
  525.     methods:
  526.  
  527.      - RadioGroup(self): constructor.
  528.      - add(self,title, value, default = None): add a button. Returns button.
  529.      - getSelection(self) : returns value of selected button | None    
  530.     """
  531.     def __init__(self):
  532.         self.prev = None
  533.         self.buttonlist = []
  534.  
  535.     def add(self, title, value, default = None):
  536.         if not self.prev and default == None:
  537.             # If the first element is not explicitly set to
  538.             # not be the default, make it be the default
  539.             default = 1
  540.         b = SingleRadioButton(title, self.prev, default)
  541.         self.prev = b
  542.         self.buttonlist.append((b, value))
  543.         return b
  544.  
  545.     def getSelection(self):
  546.         for (b, value) in self.buttonlist:
  547.             if b.selected(): return value
  548.         return None
  549.  
  550.  
  551. class RadioBar(Grid):
  552.     """ Bar of Radio buttons, based on Grid.
  553.  
  554.     methods:
  555.  
  556.     - RadioBar(self, screen, buttonlist) : constructor.
  557.     - getSelection(self): return value of selected button 
  558.     """
  559.  
  560.     def __init__(self, screen, buttonlist):
  561.         self.list = []
  562.         self.item = 0
  563.         self.group = RadioGroup()
  564.         Grid.__init__(self, 1, len(buttonlist))
  565.         for (title, value, default) in buttonlist:
  566.             b = self.group.add(title, value, default)
  567.             self.list.append((b, value))
  568.             self.setField(b, 0, self.item, anchorLeft = 1)
  569.             self.item = self.item + 1
  570.  
  571.     def getSelection(self):
  572.         return self.group.getSelection()
  573.     
  574.  
  575. # you normally want to pack a ButtonBar with growx = 1
  576.  
  577. class ButtonBar(Grid):
  578.     """ Bar of buttons, based on grid.
  579.  
  580.     methods:
  581.  
  582.      - ButtonBar(screen, buttonlist,buttonlist, compact = 0):
  583.      - buttonPressed(self, result):  Takes the widget returned by Form.run and looks to see
  584.                      if it was one of the widgets in the ButtonBar.
  585.     """
  586.     def __init__(self, screen, buttonlist, compact = 0):
  587.         self.list = []
  588.         self.hotkeys = {}
  589.         self.item = 0
  590.         Grid.__init__(self, len(buttonlist), 1)
  591.         for blist in buttonlist:
  592.             if (type(blist) == types.StringType):
  593.                 title = blist
  594.                 value = string.lower(blist)
  595.             elif len(blist) == 2:
  596.                 (title, value) = blist
  597.             else:
  598.                 (title, value, hotkey) = blist
  599.                 self.hotkeys[hotkey] = value
  600.  
  601.             if compact:
  602.                 b = CompactButton(title)
  603.             else:
  604.                 b = Button(title)
  605.             self.list.append((b, value))
  606.             self.setField(b, self.item, 0, (1, 0, 1, 0))
  607.             self.item = self.item + 1
  608.  
  609.     def buttonPressed(self, result):    
  610.         if self.hotkeys.has_key(result):
  611.             return self.hotkeys[result]
  612.  
  613.         for (button, value) in self.list:
  614.             if result == button:
  615.                 return value
  616.         return None
  617.  
  618.  
  619. class GridFormHelp(Grid):
  620.     """ Subclass of Grid, for the help form text.
  621.  
  622.     methods:
  623.  
  624.      - GridFormHelp(self, screen, title, help, *args) :
  625.      - add (self, widget, col, row, padding = (0, 0, 0, 0),
  626.             anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  627.             anchorBottom = 0, growx = 0, growy = 0):
  628.      - runOnce(self, x = None, y = None):  pop up the help window
  629.      - addHotKey(self, keyname):
  630.      - setTimer(self, keyname):
  631.      - create(self, x = None, y = None):
  632.      - run(self, x = None, y = None):
  633.      - draw(self):
  634.      - runPopup(self):
  635.      - setCurrent (self, co):
  636.     """
  637.     def __init__(self, screen, title, help, *args):
  638.         self.screen = screen
  639.         self.title = title
  640.         self.form = Form(help)
  641.         self.childList = []
  642.         self.form_created = 0
  643.         args = list(args)
  644.         args[:0] = [self]
  645.         apply(Grid.__init__, tuple(args))
  646.  
  647.     def add(self, widget, col, row, padding = (0, 0, 0, 0),
  648.             anchorLeft = 0, anchorTop = 0, anchorRight = 0,
  649.             anchorBottom = 0, growx = 0, growy = 0):
  650.         self.setField(widget, col, row, padding, anchorLeft,
  651.                       anchorTop, anchorRight, anchorBottom,
  652.                       growx, growy);
  653.         self.childList.append(widget)
  654.  
  655.     def runOnce(self, x = None, y = None):
  656.         result = self.run(x, y)
  657.         self.screen.popWindow()
  658.         return result
  659.  
  660.     def addHotKey(self, keyname):
  661.         self.form.addHotKey(keyname)
  662.  
  663.     def setTimer(self, keyname):
  664.         self.form.setTimer(keyname)
  665.  
  666.     def create(self, x = None, y = None):
  667.         if not self.form_created:
  668.             self.place(1,1)
  669.             for child in self.childList:
  670.                 self.form.add(child)
  671.             self.screen.gridWrappedWindow(self, self.title, x, y)
  672.             self.form_created = 1
  673.  
  674.     def run(self, x = None, y = None):
  675.         self.create(x, y)
  676.         return self.form.run()
  677.  
  678.     def draw(self):
  679.         self.create()
  680.         return self.form.draw()
  681.     
  682.     def runPopup(self):
  683.         self.create()
  684.         self.screen.gridWrappedWindow(self, self.title)
  685.         result = self.form.run()
  686.         self.screen.popWindow()
  687.         return result
  688.  
  689.     def setCurrent (self, co):
  690.         self.form.setCurrent (co)
  691.  
  692. class GridForm(GridFormHelp):
  693.     """ GridForm class (extends GridFormHelp):
  694.  
  695.     methods:
  696.  
  697.      - GridForm(self, screen, title, *args):
  698.     """
  699.     def __init__(self, screen, title, *args):
  700.         myargs = (self, screen, title, None) + args
  701.         apply(GridFormHelp.__init__, myargs)
  702.  
  703. class CheckboxTree(Widget):
  704.     """ CheckboxTree combo widget,
  705.  
  706.     methods:
  707.  
  708.      - CheckboxTree(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0)
  709.                     constructor.
  710.      - append(self, text, item = None, selected = 0):
  711.      - addItem(self, text, path, item = None, selected = 0):
  712.      - getCurrent(self):
  713.      - getSelection(self):
  714.      - setEntry(self, item, text):
  715.      - setCurrent(self, item):
  716.      - setEntryValue(self, item, selected = 1):
  717.      - getEntryValue(self, item):
  718.     """ 
  719.     def append(self, text, item = None, selected = 0):
  720.         self.addItem(text, (snackArgs['append'], ), item, selected)
  721.     
  722.     def addItem(self, text, path, item = None, selected = 0):
  723.         if item is None:
  724.             item = text
  725.         key = self.w.checkboxtreeAddItem(text, path, selected)
  726.         self.key2item[key] = item
  727.         self.item2key[item] = key
  728.  
  729.     def getCurrent(self):
  730.         curr = self.w.checkboxtreeGetCurrent()
  731.         return self.key2item[curr]
  732.  
  733.     def __init__(self, height, scroll = 0, width = None, hide_checkbox = 0, unselectable = 0):
  734.         self.w = _snack.checkboxtree(height, scroll, hide_checkbox, unselectable)
  735.         self.key2item = {}
  736.         self.item2key = {}
  737.         if (width):
  738.             self.w.checkboxtreeSetWidth(width)
  739.  
  740.     def getSelection(self):
  741.         selection = []
  742.         list = self.w.checkboxtreeGetSelection()
  743.         for key in list:
  744.             selection.append(self.key2item[key])
  745.         return selection
  746.  
  747.     def setEntry(self, item, text):
  748.         self.w.checkboxtreeSetEntry(self.item2key[item], text)
  749.  
  750.     def setCurrent(self, item):
  751.         self.w.checkboxtreeSetCurrent(self.item2key[item])
  752.  
  753.     def setEntryValue(self, item, selected = 1):
  754.         self.w.checkboxtreeSetEntryValue(self.item2key[item], selected)
  755.  
  756.     def getEntryValue(self, item):
  757.         return self.w.checkboxtreeGetEntryValue(self.item2key[item])
  758.  
  759. def ListboxChoiceWindow(screen, title, text, items, 
  760.             buttons = ('Ok', 'Cancel'), 
  761.             width = 40, scroll = 0, height = -1, default = None,
  762.             help = None):
  763.     """
  764.     - ListboxChoiceWindow(screen, title, text, items, 
  765.             buttons = ('Ok', 'Cancel'), 
  766.             width = 40, scroll = 0, height = -1, default = None,
  767.             help = None):
  768.     """
  769.     if (height == -1): height = len(items)
  770.  
  771.     bb = ButtonBar(screen, buttons)
  772.     t = TextboxReflowed(width, text)
  773.     l = Listbox(height, scroll = scroll, returnExit = 1)
  774.     count = 0
  775.     for item in items:
  776.         if (type(item) == types.TupleType):
  777.             (text, key) = item
  778.         else:
  779.             text = item
  780.             key = count
  781.  
  782.         if (default == count):
  783.             default = key
  784.         elif (default == item):
  785.             default = key
  786.  
  787.         l.append(text, key)
  788.         count = count + 1
  789.  
  790.     if (default != None):
  791.         l.setCurrent (default)
  792.  
  793.     g = GridFormHelp(screen, title, help, 1, 3)
  794.     g.add(t, 0, 0)
  795.     g.add(l, 0, 1, padding = (0, 1, 0, 1))
  796.     g.add(bb, 0, 2, growx = 1)
  797.  
  798.     rc = g.runOnce()
  799.  
  800.     return (bb.buttonPressed(rc), l.current())
  801.  
  802. def ButtonChoiceWindow(screen, title, text, 
  803.                buttons = [ 'Ok', 'Cancel' ], 
  804.                width = 40, x = None, y = None, help = None):
  805.     """
  806.      - ButtonChoiceWindow(screen, title, text, 
  807.                buttons = [ 'Ok', 'Cancel' ], 
  808.                width = 40, x = None, y = None, help = None):
  809.     """
  810.     bb = ButtonBar(screen, buttons)
  811.     t = TextboxReflowed(width, text, maxHeight = screen.height - 12)
  812.  
  813.     g = GridFormHelp(screen, title, help, 1, 2)
  814.     g.add(t, 0, 0, padding = (0, 0, 0, 1))
  815.     g.add(bb, 0, 1, growx = 1)
  816.     return bb.buttonPressed(g.runOnce(x, y))
  817.  
  818. def EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
  819.         entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
  820.     """
  821.     EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
  822.         entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
  823.     """
  824.     bb = ButtonBar(screen, buttons);
  825.     t = TextboxReflowed(width, text)
  826.  
  827.     count = 0
  828.     for n in prompts:
  829.         count = count + 1
  830.  
  831.     sg = Grid(2, count)
  832.  
  833.     count = 0
  834.     entryList = []
  835.     for n in prompts:
  836.         if (type(n) == types.TupleType):
  837.             (n, e) = n
  838.             if (type(e) in types.StringTypes):
  839.                 e = Entry(entryWidth, e)
  840.         else:
  841.             e = Entry(entryWidth)
  842.  
  843.         sg.setField(Label(n), 0, count, padding = (0, 0, 1, 0), anchorLeft = 1)
  844.         sg.setField(e, 1, count, anchorLeft = 1)
  845.         count = count + 1
  846.         entryList.append(e)
  847.  
  848.     g = GridFormHelp(screen, title, help, 1, 3)
  849.  
  850.     g.add(t, 0, 0, padding = (0, 0, 0, 1))
  851.     g.add(sg, 0, 1, padding = (0, 0, 0, 1))
  852.     g.add(bb, 0, 2, growx = 1)
  853.  
  854.     result = g.runOnce()
  855.  
  856.     entryValues = []
  857.     count = 0
  858.     for n in prompts:
  859.         entryValues.append(entryList[count].value())
  860.         count = count + 1
  861.  
  862.     return (bb.buttonPressed(result), tuple(entryValues))
  863.  
  864. class CListbox(Grid):
  865.     """Clistbox convenience class.
  866.  
  867.     methods:
  868.  
  869.      - Clistbox(self, height, cols, cols_widths, scroll = 0)       : constructor
  870.      - colFormText(self, col_text, align = None, adjust_width = 0) : column text.
  871.      - append(self, col_text, item, col_text_align = None)         :
  872.      - insert(self, col_text, item, before, col_text_align = None)
  873.      - delete(self, item)
  874.      - replace(self, col_text, item, col_text_align = None)
  875.      - current(self) : returns current item
  876.      - setCurrent(self, item): sets an item as current
  877.      - clear(self): clear the listbox
  878.      
  879.      Alignments may be LEFT, RIGHT, CENTER, None
  880.     """
  881.     def __init__(self, height, cols, col_widths, scroll = 0,
  882.                  returnExit = 0, width = 0, col_pad = 1,
  883.                  col_text_align = None, col_labels = None,
  884.                  col_label_align = None, adjust_width=0):
  885.  
  886.         self.cols = cols
  887.         self.col_widths = col_widths[:]
  888.         self.col_pad = col_pad
  889.         self.col_text_align = col_text_align
  890.  
  891.         if col_labels != None:        
  892.             Grid.__init__(self, 1, 2)
  893.             box_y = 1
  894.  
  895.             lstr = self.colFormText(col_labels, col_label_align,
  896.                                                 adjust_width=adjust_width)
  897.             self.label = Label(lstr)
  898.             self.setField(self.label, 0, 0, anchorLeft=1)
  899.  
  900.         else:
  901.             Grid.__init__(self, 1, 1)
  902.             box_y = 0
  903.             
  904.  
  905.         self.listbox = Listbox(height, scroll, returnExit, width)
  906.         self.setField(self.listbox, 0, box_y, anchorRight=1)
  907.  
  908.     def colFormText(self, col_text, align = None, adjust_width=0):
  909.         i = 0
  910.         str = ""
  911.         c_len = len(col_text)
  912.         while (i < self.cols) and (i < c_len):
  913.         
  914.             cstr = col_text[i]
  915.             cstrlen = _snack.wstrlen(cstr)
  916.             if self.col_widths[i] < cstrlen:
  917.                 if adjust_width:
  918.                     self.col_widths[i] = cstrlen
  919.                 else:
  920.                     cstr = cstr[:self.col_widths[i]]
  921.  
  922.             delta = self.col_widths[i] - _snack.wstrlen(cstr)
  923.                         
  924.             if delta > 0:
  925.                 if align == None:
  926.                     a = LEFT
  927.                 else:
  928.                     a = align[i]
  929.  
  930.                 if a == LEFT:
  931.                     cstr = cstr + (" " * delta)
  932.                 if a == CENTER:
  933.                     cstr = (" " * (delta / 2)) + cstr + \
  934.                         (" " * ((delta + 1) / 2))
  935.                 if a == RIGHT:
  936.                     cstr = (" " * delta) + cstr
  937.  
  938.             if i != c_len - 1:
  939.                 pstr = (" " * self.col_pad)
  940.             else:
  941.                 pstr = ""
  942.  
  943.             str = str + cstr + pstr
  944.     
  945.             i = i + 1
  946.     
  947.         return str
  948.  
  949.     def append(self, col_text, item, col_text_align = None):
  950.         if col_text_align == None:
  951.             col_text_align = self.col_text_align
  952.         text = self.colFormText(col_text, col_text_align)
  953.         self.listbox.append(text, item)
  954.  
  955.     def insert(self, col_text, item, before, col_text_align = None):
  956.         if col_text_align == None:
  957.             col_text_align = self.col_text_align
  958.         text = self.colFormText(col_text, col_text_align)
  959.         self.listbox.insert(text, item, before)
  960.  
  961.     def delete(self, item):
  962.         self.listbox.delete(item)
  963.  
  964.     def replace(self, col_text, item, col_text_align = None):
  965.         if col_text_align == None:
  966.             col_text_align = self.col_text_align
  967.         text = self.colFormText(col_text, col_text_align)
  968.         self.listbox.replace(text, item)
  969.  
  970.     def current(self):
  971.         return self.listbox.current()
  972.  
  973.     def setCurrent(self, item):
  974.         self.listbox.setCurrent(item)
  975.  
  976.     def clear(self):
  977.         self.listbox.clear()
  978.